home *** CD-ROM | disk | FTP | other *** search
/ Kit PC World De Ampliacion De Windows 95 / Kit PC World de ampliacion de Windows 95.iso / internet / sweeper / samples / surfbear / intern~1.cpp < prev    next >
C/C++ Source or Header  |  1995-12-04  |  8KB  |  284 lines
  1. #include "stdafx.h"
  2. #include "InternetThread.h"
  3.  
  4.  
  5. //
  6. // Helper function
  7. //
  8. BOOL Succeeded(HANDLE h, LPCTSTR strFunctionName) ;
  9.  
  10. //
  11. // Constructor
  12. //
  13. CInternetThread::CInternetThread()
  14.    : m_hPostMsgWnd(NULL), 
  15.       m_hSession(NULL), 
  16.       m_buffer(NULL),
  17.       m_dwAccessType(PRE_CONFIG_INTERNET_ACCESS)
  18. {
  19. }
  20.  
  21. //
  22. // Closes the Internet session so InternetOpen will be called on next GetPage.
  23. //
  24. void CInternetThread::ResetSession()
  25. {
  26.    TRACE0("Resetting Session\r\n") ;
  27.    if (m_hSession != NULL)
  28.    {
  29.       VERIFY(::InternetCloseHandle(m_hSession)) ;
  30.       m_hSession == NULL ;
  31.    }   
  32. }
  33.  
  34. //
  35. // 
  36. //
  37. CInternetThread::~CInternetThread()
  38. {
  39.    if (m_buffer) delete m_buffer ;
  40.    ResetSession(); 
  41. }
  42.  
  43. //
  44. // 
  45. //
  46. BOOL CInternetThread::Init(HWND hPostMsgWnd)
  47. {
  48.    ASSERT(hPostMsgWnd) ;
  49.    m_hPostMsgWnd = hPostMsgWnd ;
  50.  
  51.    return TRUE ;
  52. }
  53.  
  54. //
  55. // Returns an Index which represents the AccessType. Used by CAccessTypeDlg
  56. //
  57.  
  58. int CInternetThread::GetAccessTypeIndex() 
  59. {
  60.    // This function is tied to the dialog box...
  61.    int index = 0 ;
  62.    switch (m_dwAccessType)
  63.    {
  64.    case PRE_CONFIG_INTERNET_ACCESS:
  65.       index = 0 ;
  66.       break ;
  67.    case GATEWAY_INTERNET_ACCESS:
  68.       index = 1 ;
  69.       break ;
  70.    case CERN_PROXY_INTERNET_ACCESS:
  71.       index = 2 ;
  72.       break ;
  73.    case LOCAL_INTERNET_ACCESS:
  74.       index = 3 ;
  75.       break ;
  76.    default:
  77.       ASSERT(0) ;
  78.    }
  79.    return index ;
  80. }
  81.  
  82. //
  83. // Sets the Access Type using an Index returned from the CAccessTypeDlg
  84. //
  85. void CInternetThread::SetAccessTypeIndex(int index) 
  86. {
  87.    // This function is tied to the dialog box...
  88.    switch(index)
  89.    {
  90.    case 0:
  91.       m_dwAccessType = PRE_CONFIG_INTERNET_ACCESS ;
  92.       break;
  93.    case 1:
  94.       m_dwAccessType = GATEWAY_INTERNET_ACCESS ;
  95.       break;
  96.    case 2:
  97.       m_dwAccessType = CERN_PROXY_INTERNET_ACCESS ;
  98.       break;
  99.    case 3:
  100.       m_dwAccessType = LOCAL_INTERNET_ACCESS ;
  101.       break;
  102.    default:
  103.       ASSERT(0) ;
  104.    }
  105.    ResetSession() ;
  106. }
  107.  
  108. //
  109. // Varify that rAddress is partially valid. Start the worker thread to get a web page.
  110. //
  111. void CInternetThread::GetPage(CString& rAddress)
  112. {
  113.    ASSERT(!rAddress.IsEmpty()) ;
  114.    //
  115.    // Parse the http address for the server and file names
  116.    //
  117.    CString strTemp = rAddress.Mid(7) ; // Remove http://
  118.    int i = strTemp.Find("/"); // Filename on address?
  119.    if (i != -1)
  120.    {
  121.       m_strServer = strTemp.Left(i) ;
  122.       m_strPath = strTemp.Mid(i) ;
  123.       TRACE("Path = [%s]", (LPCTSTR)m_strPath) ; 
  124.   }
  125.    else
  126.       m_strServer = strTemp ;
  127.  
  128.    TRACE("\t Server = [%s] \r\n", (LPCTSTR)m_strServer) ;   
  129.  
  130.    ASSERT(IsBufferEmpty()) ;
  131.    //
  132.    // Start a worker thread to get the web page.
  133.    //
  134.    AfxBeginThread(GetWebPageWorkerThread, this) ;
  135. }
  136.  
  137. //
  138. // This is the thread function. 
  139. //
  140. UINT CInternetThread::GetWebPageWorkerThread(LPVOID pvThread)
  141. {
  142.    TRACE0("GetWebPageWorkerThread\r\n") ;
  143.  
  144.    CInternetThread* pInternetThread = (CInternetThread*) pvThread ;
  145.    if (pInternetThread == NULL 
  146.        || pInternetThread->m_strServer.IsEmpty()
  147.          || pInternetThread->m_hPostMsgWnd == NULL)
  148.    {
  149.       TRACE0("InternetThread isn't a valid\r\n") ;
  150.       return THREAD_BAD ;
  151.    }
  152.  
  153.    return pInternetThread->_GetPageWorker() ;
  154. }
  155.  
  156. //
  157. // This is where all of the actually Internet work is done.
  158. //
  159. UINT CInternetThread::_GetPageWorker()
  160. {
  161.     UINT uiResult = THREAD_BAD;
  162.  
  163.     if (m_hSession == NULL)
  164.    {
  165.       //
  166.       // Initialize the Internet Functions.
  167.       //
  168.       TRACE("Starting Session (Access = %i) (Proxy = %s)\r\n",
  169.             GetAccessTypeIndex(),
  170.             (LPCTSTR)m_strProxyServer) ;
  171.       m_hSession = ::InternetOpen("MSDN SurfBear",
  172.                                   m_dwAccessType,
  173.                                   m_strProxyServer,
  174.                                   INVALID_PORT_NUMBER,
  175.                                   0 ) ;
  176.  
  177.       if (!Succeeded(m_hSession, "InternetOpen"))
  178.       {
  179.          // Send message to UI that we finished.
  180.          ::PostMessage(m_hPostMsgWnd,WM_READFILECOMPLETED, NULL, (LPARAM)THREAD_BAD) ;
  181.  
  182.          return THREAD_BAD;
  183.       }
  184.    }
  185.  
  186.    HINTERNET hConnect = ::InternetConnect(m_hSession,
  187.                                           m_strServer,
  188.                                           INVALID_PORT_NUMBER,
  189.                                           "",
  190.                                           "",
  191.                                           INTERNET_SERVICE_HTTP,
  192.                                           0,
  193.                                           0) ;
  194.  
  195.                                           
  196.    if (Succeeded(hConnect, "InternetConnect"))
  197.    {
  198.  
  199.       HINTERNET hHttpFile = ::HttpOpenRequest(hConnect,
  200.                                               "GET",
  201.                                               m_strPath,
  202.                                               HTTP_VERSION,
  203.                                               "",
  204.                                               0,
  205.                                               INTERNET_OPEN_FLAG_NO_CACHE,
  206.                                               0) ;
  207.  
  208.       if (Succeeded(hHttpFile, "HttpOpenRequest"))
  209.       {
  210.          
  211.          BOOL bSendRequest = ::HttpSendRequest(hHttpFile, "", 0, 0, 0);
  212.          
  213.          if (Succeeded((HINTERNET)bSendRequest, "HttpSendRequest"))
  214.          {
  215.             // Get size of file.
  216.             char bufQuery[32] ;
  217.             DWORD dwFileSize ;
  218.             DWORD dwLengthBufQuery = sizeof (bufQuery);
  219.             BOOL bQuery = ::HttpQueryInfo(hHttpFile,
  220.                            HTTP_QUERY_CONTENT_LENGTH, 
  221.                            bufQuery, 
  222.                            &dwLengthBufQuery) ;
  223.             if (Succeeded((HINTERNET)bQuery, "HttpQueryInfo"))
  224.             {
  225.                // The Query was successful, so allocate the memory.
  226.                TRACE("HttpQueryInfo FileSize is %s.\r\n", bufQuery) ;
  227.                dwFileSize = (DWORD)atol(bufQuery) ;
  228.             }
  229.             else
  230.             {
  231.                // The Query failed. Allocate some memory. Should allocate memory in blocks.
  232.                TRACE("\tQueryInfo Failed. Just get 5k.\r\n") ;
  233.                dwFileSize = 5*1024 ;
  234.             }
  235.  
  236.             ASSERT(m_buffer == NULL); 
  237.             m_buffer = new char[dwFileSize+1] ;
  238.             DWORD dwBytesRead ;
  239.             BOOL bRead = ::InternetReadFile(hHttpFile,    
  240.                                             m_buffer,    
  241.                                             dwFileSize+1,     
  242.                                             &dwBytesRead);    
  243.             if (Succeeded((HINTERNET)bRead, "InternetReadFile"))
  244.             {
  245.                TRACE("\tBytes Read is %d\r\n", dwBytesRead) ;
  246.                m_buffer[dwBytesRead] = 0 ;
  247.                uiResult = THREAD_GOOD;
  248.             } // InternetReadFile
  249.          } // HttpSendRequest
  250.  
  251.          VERIFY(::InternetCloseHandle(hHttpFile)); 
  252.       } // HttpOpenRequest
  253.  
  254.       VERIFY(::InternetCloseHandle(hConnect)) ;
  255.    } // InternetConnect 
  256.  
  257.    ::PostMessage(m_hPostMsgWnd,WM_READFILECOMPLETED, NULL, (LPARAM)uiResult) ;
  258.  
  259.    return uiResult ;
  260. }
  261.  
  262. //
  263. //
  264. //
  265. BOOL Succeeded(HANDLE h, LPCTSTR strFunctionName)
  266. {
  267.    if (h == NULL)
  268.    {
  269.       DWORD dwError = GetLastError() ;
  270.       TRACE("%s *** Error = %u***\r\n",strFunctionName, dwError) ;
  271.  
  272.       CString errString ;
  273.       errString.Format("%s returns error %u", strFunctionName, dwError) ;
  274.       AfxMessageBox(errString, MB_ICONEXCLAMATION | MB_OK) ;
  275.       return FALSE;
  276.    }
  277.    else
  278.    {
  279.       TRACE("%s\r\n", strFunctionName) ;
  280.       return TRUE ;
  281.    }
  282.  
  283. }
  284.